In the domain of software application development, some of the most widespread difficulties relate to inefficient use of computer memory. However, detecting inefficient memory use in a manner that can be useful to software developers has been an exceptionally difficult task. As a result, there are few tools on the market today that can provide any but the most rudimentary aid in identifying inefficient memory use.
One reason for the difficulties associated with inefficient memory use is that memory is largely invisible to both users and developers at any but the highest levels of abstraction. For example, a process executing on a computer has at least one memory heap allocated for its execution, but in many cases that process can have several memory heaps. Over time, a heap's memory can become fragmented, just as hard disk drives do. Yet, conventional tools provide no ability to observe or even detect this fragmentation. Yet, the consequences of memory fragmentation can be just as problematic as hard disk drive fragmentation.
Furthermore, many memory heaps internally allocate virtual memory for associated use. Yet, these internal allocations are not necessarily efficient. For example, in many cases much of the internally allocated memory is not actually used by an associated application or process. Moreover, it is very common for some memory allocations to be duplicates, and therefore an unnecessary use of memory. Yet conventional tools do not provide any useful way to detect such duplicates.
Still another difficulty that exists in this domain is that some memory allocations result in over-allocation of the memory. For example, a memory allocation call can request 100 bytes, but only 10 bytes are use. Thus, 90 bytes of the memory allocation is wasted. Existing tools cannot detect these inefficient uses. Further, some memory allocation requests are for 0 bytes. These request incur overhead and affect fragmentation, but, like other difficulties noted supra, have no satisfactory existing mechanism for detection.
Still further, a process can have many files or sections of files mapped into its memory space. In some cases, there is shared memory between processes, yet these features are not readily observable today. Virtual memory can be freely allocated by an application or process, yet in conventional terms, it is not readily discernable what code was responsible for these memory allocations. In fact, many memory allocations can originate from managed code that is not explicitly issued by native instructions.
The above-described deficiencies of today's techniques are merely intended to provide an overview of some of the problems of conventional systems, and are not intended to be exhaustive. Other problems with conventional systems and corresponding benefits of the various non-limiting embodiments described herein may become further apparent upon review of the following description.